home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / uio_reqs.c < prev    next >
Text File  |  1993-08-23  |  41KB  |  1,377 lines
  1. /* uio_reqs.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. /*************************************************************/
  25. /*                                                           */
  26. /*    uio_reqs.c - User IO requests to NeuralWorks           */
  27. /*    Author: John C. Fairman           August 31, 1990      */
  28. /*    Copyright 1990 by NeuralWare Inc.                      */
  29. /*                                                           */
  30. /*    $Author   :  $                                         */
  31. /*    $Date     :  $                                         */
  32. /*    $Source   :  $                                         */
  33. /*    $Revision :  $                                         */
  34. /*    $Log      :  $                                         */
  35. /*                                                           */
  36. /*************************************************************/
  37.  
  38. #include "host.h"
  39.  
  40. #if defined(SUN)
  41. #include <sys/types.h>
  42. #endif
  43.  
  44. #ifdef MPW3
  45. #include <StdDef.h>
  46. #endif
  47.  
  48. #define UIO_SERVER             1
  49. #define SKIP_COMPAT_DATA       1
  50. #define HOME_FOR_UIO_DATA      1
  51. #include "userutl.h"
  52. #include "uio_strc.h"
  53. #include "uio_tran.h"
  54.  
  55. #include <string.h>
  56.  
  57. #if defined(_MSC_VER) || defined(__TURBOC__)
  58. EXPORT VOID Send_request( VOID );
  59. LOCAL VOID send_request_with_id( VOID );
  60. #endif
  61.  
  62. #ifdef THINK_C
  63. #include "macuio.redef"
  64. #endif
  65.  
  66. #ifdef DLC
  67. /* --- prototypes --- */
  68.  
  69. /* InitGMenu( GMENU *, int, int ); */    /* Initialize a menu */
  70. /* DispGMenu( GMENU * ); */       /* Display graphics menu */
  71. /* DispGItem( GMENU *, GMENU_ITEM *, int, int ); */ /* Display menu item */
  72. /* GMENU_ITEM *LookGMenu( GMENU *, int * ); */ /* Look at graphics menu */
  73. #else
  74. GMENU_ITEM *LookGMenu();
  75. #endif
  76.  
  77. #if defined(MSDOS)
  78. #include <string.h>
  79. #endif
  80.  
  81. #define INALC 20
  82.  
  83. /* FUNCTION */
  84. LOCAL VOID send_request_with_id()
  85. {
  86.    Data_transfer_ptr->RPC_area.process_from_id = (BUFFER_INT)Process_id;
  87.    Data_transfer_ptr->RPC_area.process_to_id = (BUFFER_INT)HOST_PROCESS_ID;
  88.    Send_request();
  89.    if ((Data_transfer_ptr->RPC_area.request >= 0x80) &&      /* ERROR */
  90.        (Data_transfer_ptr->RPC_area.request < 0xC0))
  91.       {
  92.          UIO_error_value = Data_transfer_ptr->RPC_area.request;
  93.       }
  94. }
  95.  
  96. /* FUNCTION */
  97. EXPORT TEXT *GetStr()
  98. {
  99.    RPC_AREA_T  *rpc;
  100.    static TEXT ag_msg[MAX_UIO_STRING];
  101.    
  102.    rpc = &Data_transfer_ptr->RPC_area;
  103.    rpc->request = REQ_GETSTR;
  104.    
  105.    send_request_with_id();
  106.    
  107.    strcpy(ag_msg, rpc->all_arg_lists.argmsg.ag_msg);
  108.    
  109.    return(ag_msg);
  110. }
  111.  
  112. /* FUNCTION */
  113. EXPORT VOID PutStr( sp )
  114. TEXT *sp;
  115. {
  116.    RPC_AREA_T *rpc;
  117.    
  118.    rpc = &Data_transfer_ptr->RPC_area;
  119.    rpc->request = REQ_PUTSTR;
  120.    strcpy(rpc->all_arg_lists.argmsg.ag_msg, sp);
  121.    
  122.    send_request_with_id();
  123. }
  124.  
  125. /* */
  126. /* FUNCTION */
  127. EXPORT VOID PutFmt(fmt, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  128.                    b0, b1, b2, b3, b4, b5, b6, b7, b8, b9)
  129. TEXT *fmt;
  130. UL   a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  131.    b0, b1, b2, b3, b4, b5, b6, b7, b8, b9;
  132. {
  133.    RPC_AREA_T *rpc;
  134.    ARGFMT     *argfmt;
  135.    
  136.    rpc = &Data_transfer_ptr->RPC_area;
  137.    rpc->request = REQ_PUTFMT;
  138.    argfmt = &rpc->all_arg_lists.argfmt;
  139.    
  140. #if (PIGS_EVER_FLY)
  141.    strcpy(argfmt->format, fmt);
  142.    argfmt->format_args[ 0] = a0;
  143.    argfmt->format_args[ 1] = a1;
  144.    argfmt->format_args[ 2] = a2;
  145.    argfmt->format_args[ 3] = a3;
  146.    argfmt->format_args[ 4] = a4;
  147.    argfmt->format_args[ 5] = a5;
  148.    argfmt->format_args[ 6] = a6;
  149.    argfmt->format_args[ 7] = a7;
  150.    argfmt->format_args[ 8] = a8;
  151.    argfmt->format_args[ 9] = a9;
  152.    argfmt->format_args[10] = b0;
  153.    argfmt->format_args[11] = b1;
  154.    argfmt->format_args[12] = b2;
  155.    argfmt->format_args[13] = b3;
  156.    argfmt->format_args[14] = b4;
  157.    argfmt->format_args[15] = b5;
  158.    argfmt->format_args[16] = b6;
  159.    argfmt->format_args[17] = b7;
  160.    argfmt->format_args[18] = b8;
  161.    argfmt->format_args[19] = b9;
  162. #else
  163.    /* CCK: 12-Apr-91 This is the one that works!! */
  164.    sprintf(argfmt->format, fmt,
  165.            a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  166.            b0, b1, b2, b3, b4, b5, b6, b7, b8, b9);
  167. #endif
  168.    
  169.    send_request_with_id();
  170. }
  171.  
  172. /* FUNCTION */
  173. EXPORT NINT SaveNet( NetName, Mode )
  174. TEXT *NetName;
  175. NINT Mode;       /* 0=binary, 1=ascii, 2=annotated, 3=screen dump */
  176. {
  177.    RPC_AREA_T *rpc;
  178.    
  179.    rpc = &Data_transfer_ptr->RPC_area;
  180.    rpc->request = REQ_SAVENET;
  181.    strcpy(rpc->all_arg_lists.argn.ag_NetN, NetName);
  182.    rpc->all_arg_lists.argn.ag_mode = (BUFFER_UINT)Mode;
  183.    
  184.    send_request_with_id();
  185.  
  186.    return((NINT)rpc->return_value.buffer_int);
  187. }
  188.  
  189.  
  190. /* */
  191. /*****************************************************************************/
  192. /*                                                                           */
  193. /*    Graphic Routine interfaces for NWORKS                                  */
  194. /*                                                                           */
  195. /*****************************************************************************/
  196.  
  197. /* FUNCTION */
  198. EXPORT VOID ug_window( key, bkcolor, x0, y0, x1, y1 )
  199. NINT key;        /* window number for a handle (1..8) */
  200. NINT bkcolor;    /* background color */
  201. NINT x0, y0;     /* screen coordinates of origin (bottom left corner) */
  202. NINT x1, y1;     /* screen coordinates of top right corner */
  203. {
  204.    RPC_AREA_T *rpc;
  205.    ARG1       *arg1;
  206.    
  207.    rpc = &Data_transfer_ptr->RPC_area;
  208.    rpc->request = REQ_UG_WINDOW;
  209.    arg1 = &rpc->all_arg_lists.arg1;
  210.    arg1->ag_winn = (BUFFER_UINT)key;
  211.    arg1->ag_color = (BUFFER_UINT)bkcolor;
  212.    arg1->ag_x0 = (BUFFER_UINT)x0;
  213.    arg1->ag_y0 = (BUFFER_UINT)y0;
  214.    arg1->ag_x1 = (BUFFER_UINT)x1;
  215.    arg1->ag_y1 = (BUFFER_UINT)y1;
  216.    
  217.    send_request_with_id();
  218. }
  219.  
  220. /* FUNCTION */
  221. EXPORT VOID ug_line( key, color, mode, x0, y0, x1, y1, style )
  222. NINT key;        /* window number for a handle (1..8) */
  223. NINT color;      /* color index */
  224. NINT mode;       /* 0=set, 1=xor */
  225. NINT x0, y0;     /* window relative coordinates for origin */
  226. NINT x1, y1;     /* window relative coordinates for end */
  227. NINT style;      /* line style */
  228. {
  229.    RPC_AREA_T *rpc;
  230.    ARG2       *arg2;
  231.    
  232.    rpc = &Data_transfer_ptr->RPC_area;
  233.    rpc->request = REQ_UG_LINE;
  234.    arg2 = &rpc->all_arg_lists.arg2;
  235.    arg2->ag_winn = (BUFFER_UINT)key;
  236.    arg2->ag_color = (BUFFER_UINT)color;
  237.    arg2->ag_mode = (BUFFER_UINT)mode;
  238.    arg2->ag_x0 = (BUFFER_UINT)x0;
  239.    arg2->ag_y0 = (BUFFER_UINT)y0;
  240.    arg2->ag_x1 = (BUFFER_UINT)x1;
  241.    arg2->ag_y1 = (BUFFER_UINT)y1;
  242.    arg2->ag_style = (BUFFER_UINT)style;
  243.    
  244.    send_request_with_id();
  245. }
  246.  
  247. /* FUNCTION */
  248. EXPORT VOID ug_circle( key, color, mode, x0, y0, rad, fill )
  249. NINT key;        /* window number for a handle (1..8) */
  250. NINT color;      /* color index */
  251. NINT mode;       /* 0=set, 1=xor */
  252. NINT x0, y0;     /* window relative coordinates for origin */
  253. NINT rad;        /* radius */
  254. NINT fill;       /* fill flag */
  255. {
  256.    RPC_AREA_T *rpc;
  257.    ARG2       *arg2;
  258.    
  259.    rpc = &Data_transfer_ptr->RPC_area;
  260.    rpc->request = REQ_UG_CIRCLE;
  261.    arg2 = &rpc->all_arg_lists.arg2;
  262.    arg2->ag_winn = (BUFFER_UINT)key;
  263.    arg2->ag_color = (BUFFER_UINT)color;
  264.    arg2->ag_mode = (BUFFER_UINT)mode;
  265.    arg2->ag_x0 = (BUFFER_UINT)x0;
  266.    arg2->ag_y0 = (BUFFER_UINT)y0;
  267.    arg2->ag_x1 = (BUFFER_UINT)rad;
  268.    arg2->ag_style = (BUFFER_UINT)fill;
  269.    
  270.    send_request_with_id();
  271. }
  272.  
  273. /* */
  274. /* FUNCTION */
  275. EXPORT VOID ug_point( key, color, mode, x0, y0 )
  276. NINT key;        /* window number for a handle (1..8) */
  277. NINT color;      /* color index */
  278. NINT mode;       /* 0=set, 1=xor */
  279. NINT x0, y0;     /* window relative coordinates for point */
  280. {
  281.    RPC_AREA_T *rpc;
  282.    ARG2       *arg2;
  283.    
  284.    rpc = &Data_transfer_ptr->RPC_area;
  285.    rpc->request = REQ_UG_POINT;
  286.    arg2 = &rpc->all_arg_lists.arg2;
  287.    arg2->ag_winn = (BUFFER_UINT)key;
  288.    arg2->ag_color = (BUFFER_UINT)color;
  289.    arg2->ag_mode = (BUFFER_UINT)mode;
  290.    arg2->ag_x0 = (BUFFER_UINT)x0;
  291.    arg2->ag_y0 = (BUFFER_UINT)y0;
  292.    
  293.    send_request_with_id();
  294. }
  295.  
  296. /* FUNCTION */
  297. EXPORT VOID ug_box( key, color, mode, x0, y0, x1, y1, style )
  298. NINT key;        /* window number for a handle (1..8) */
  299. NINT color;      /* color index */
  300. NINT mode;       /* 0=set, 1=xor */
  301. NINT x0, y0;     /* window relative coordinates for lower left corner */
  302. NINT x1, y1;     /* window relative coordinates for upper right corner */
  303. NINT style;      /* line style */
  304. {
  305.    RPC_AREA_T *rpc;
  306.    ARG2       *arg2;
  307.    
  308.    rpc = &Data_transfer_ptr->RPC_area;
  309.    rpc->request = REQ_UG_BOX;
  310.    arg2 = &rpc->all_arg_lists.arg2;
  311.    arg2->ag_winn = (BUFFER_UINT)key;
  312.    arg2->ag_color = (BUFFER_UINT)color;
  313.    arg2->ag_mode = (BUFFER_UINT)mode;
  314.    arg2->ag_x0 = (BUFFER_UINT)x0;
  315.    arg2->ag_y0 = (BUFFER_UINT)y0;
  316.    arg2->ag_x1 = (BUFFER_UINT)x1;
  317.    arg2->ag_y1 = (BUFFER_UINT)y1;
  318.    arg2->ag_style = (BUFFER_UINT)style;
  319.    
  320.    send_request_with_id();
  321. }
  322.  
  323. /* */
  324. /* FUNCTION */
  325. EXPORT VOID ug_boxf( key, color, mode, x0, y0, x1, y1 )
  326. NINT key;        /* window number for a handle (1..8) */
  327. NINT color;      /* color index */
  328. NINT mode;       /* 0=set, 1=xor */
  329. NINT x0, y0;     /* window relative coordinates for lower left corner */
  330. NINT x1, y1;     /* window relative coordinates for upper right corner */
  331. {
  332.    RPC_AREA_T *rpc;
  333.    ARG2 *arg2;
  334.    
  335.    rpc = &Data_transfer_ptr->RPC_area;
  336.    rpc->request = REQ_UG_BOXF;
  337.    arg2 = &rpc->all_arg_lists.arg2;
  338.    arg2->ag_winn = (BUFFER_UINT)key;
  339.    arg2->ag_color = (BUFFER_UINT)color;
  340.    arg2->ag_mode = (BUFFER_UINT)mode;
  341.    arg2->ag_x0 = (BUFFER_UINT)x0;
  342.    arg2->ag_y0 = (BUFFER_UINT)y0;
  343.    arg2->ag_x1 = (BUFFER_UINT)x1;
  344.    arg2->ag_y1 = (BUFFER_UINT)y1;
  345.    
  346.    send_request_with_id();
  347. }
  348.  
  349. /* FUNCTION */
  350. EXPORT VOID ug_puts( key, color, mode, x0, y0, sp, rot )
  351. NINT key;        /* window number for a handle (1..8) */
  352. NINT color;      /* color index */
  353. NINT mode;       /* 0=set, 1=xor */
  354. NINT x0, y0;     /* window relative coordinates for lower left corner */
  355. TEXT *sp;        /* string to draw */
  356. NINT rot;        /* rotation angle */
  357. {
  358.    RPC_AREA_T *rpc;
  359.    ARG4 *arg4;
  360.    
  361.    rpc = &Data_transfer_ptr->RPC_area;
  362.    rpc->request = REQ_UG_PUTS;
  363.    arg4 = &rpc->all_arg_lists.arg4;
  364.    arg4->ag_winn = (BUFFER_UINT)key;
  365.    arg4->ag_color = (BUFFER_UINT)color;
  366.    arg4->ag_mode = (BUFFER_UINT)mode;
  367.    arg4->ag_x0 = (BUFFER_UINT)x0;
  368.    arg4->ag_y0 =(BUFFER_UINT) y0;
  369.    strcpy((TEXT *)arg4->ag_sp, sp);
  370.    arg4->ag_rot = (BUFFER_UINT)rot;
  371.    
  372.    send_request_with_id();
  373. }
  374.  
  375. /* */
  376. /* FUNCTION */
  377. EXPORT VOID ug_windel( key )
  378. NINT key;        /* window number to delete; 0=delete all windows */
  379. {
  380.    RPC_AREA_T *rpc;
  381.    ARG3       *arg3;
  382.    
  383.    rpc = &Data_transfer_ptr->RPC_area;
  384.    rpc->request = REQ_UG_WINDEL;
  385.    arg3 = &rpc->all_arg_lists.arg3;
  386.    arg3->ag_winn = (BUFFER_UINT)key;
  387.    
  388.    send_request_with_id();
  389. }
  390.  
  391. /* FUNCTION */
  392. EXPORT VOID ug_winclr( key )
  393. NINT key;        /* clear the contents of this window */
  394. {
  395.    RPC_AREA_T *rpc;
  396.    ARG3       *arg3;
  397.    
  398.    rpc = &Data_transfer_ptr->RPC_area;
  399.    rpc->request = REQ_UG_WINCLR;
  400.    arg3 = &rpc->all_arg_lists.arg3;
  401.    arg3->ag_winn = (BUFFER_UINT)key;
  402.    
  403.    send_request_with_id();
  404. }
  405.  
  406. /* FUNCTION */
  407. EXPORT VOID ug_gparms( xsizep, ysizep, ncolorp, chrxp, chryp )
  408. NINT *xsizep;    /* width  of user area in x-pixels */
  409. NINT *ysizep;    /* height of user area in y-pixels */
  410. NINT *ncolorp;   /* # of colors (including background) */
  411. NINT *chrxp;     /* # of x-pixels in a Character */
  412. NINT *chryp;     /* # of y-pixels in a Character */
  413. {
  414.    RPC_AREA_T *rpc;
  415.    AGPARMS    *agparms;
  416.    
  417.    rpc = &Data_transfer_ptr->RPC_area;
  418.    rpc->request = REQ_UG_GPARMS;
  419.    agparms = &rpc->all_arg_lists.agparms;
  420.    
  421.    send_request_with_id();
  422.    
  423.    if (UIO_error_value == 0)
  424.       {
  425.          *xsizep = (NINT)agparms->xsize;
  426.          *ysizep = (NINT)agparms->ysize;
  427.          *ncolorp = (NINT)agparms->ncolor;
  428.          *chrxp = (NINT)agparms->chrx;
  429.          *chryp = (NINT)agparms->chry;
  430.       }
  431. }
  432.  
  433. /* */
  434. /* FUNCTION */
  435. EXPORT VOID ug_mouse( keyp, xp, yp, mp )
  436. NINT *keyp;      /* poNINTer to window number mouse is in */
  437. NINT *xp;        /* pointer to relative x-coordinate */
  438. NINT *yp;        /* pointer to relative y-coordinate */
  439. NINT *mp;        /* button press codes */
  440. {
  441.    RPC_AREA_T *rpc;
  442.    AMOUSE     *amouse;
  443.    
  444.    rpc = &Data_transfer_ptr->RPC_area;
  445.    rpc->request = REQ_UG_MOUSE;
  446.    amouse = &rpc->all_arg_lists.amouse;
  447.    
  448.    send_request_with_id();
  449.    
  450.    if (UIO_error_value == 0)
  451.       {
  452.          *keyp = (NINT)amouse->key;
  453.          *xp = (NINT)amouse->xloc;
  454.          *yp = (NINT)amouse->yloc;
  455.          *mp = (NINT)amouse->buttonstates;
  456.       }
  457. }
  458.  
  459. /* FUNCTION */
  460. EXPORT NINT ug_rdpoint( key, x0, y0 )
  461. NINT key;        /* window number for a handle (1..8) */
  462. NINT x0, y0;     /* window relative coordinates for lower left corner */
  463. {
  464.    RPC_AREA_T *rpc;
  465.    ARG3       *arg3;
  466.    
  467.    rpc = &Data_transfer_ptr->RPC_area;
  468.    rpc->request = REQ_UG_RDPOINT;
  469.    arg3 = &rpc->all_arg_lists.arg3;
  470.    arg3->ag_winn = (BUFFER_UINT)key;
  471.    arg3->ag_x0 = (BUFFER_UINT)x0;
  472.    arg3->ag_y0 = (BUFFER_UINT)y0;
  473.    
  474.    send_request_with_id();
  475.    
  476.    return((NINT)rpc->return_value.buffer_int);
  477. }
  478.  
  479. /* */
  480. /* FUNCTION */
  481. EXPORT VOID ug_rdnetinf( nlayp, ninp, noutp, ltypep, cspp, netnpp )
  482. NINT *nlayp;     /* return pointer to number of layers will be */
  483. NINT *ninp;      /* return pointer to number of inputs */
  484. NINT *noutp;     /* return pointer to number of outputs */
  485. NINT *ltypep;    /* return pointer to layer type (0=hetero; 1=auto) */
  486. TEXT **cspp;     /* return pointer to control strategy name */
  487. TEXT **netnpp;   /* return pointer to network file name */
  488. {
  489.    RPC_AREA_T  *rpc;
  490.    ARDNETINF   *ardnetinf;
  491.    static TEXT cs[FNALC]  = {0};
  492.    static TEXT netn[FNALC]= {0};
  493.    
  494.    rpc = &Data_transfer_ptr->RPC_area;
  495.    rpc->request = REQ_UG_RDNETINF;
  496.    ardnetinf = &rpc->all_arg_lists.ardnetinf;
  497.    
  498.    send_request_with_id();
  499.    
  500.    if (UIO_error_value == 0)
  501.       {
  502.          *nlayp = (NINT)ardnetinf->nlay;
  503.          *ninp = (NINT)ardnetinf->nin;
  504.          *noutp = (NINT)ardnetinf->nout;
  505.          *ltypep = (NINT)ardnetinf->ltype;
  506.          if (ardnetinf->cs[0] == '\0')
  507.             {
  508.                *cspp = *netnpp = NULL;
  509.             }
  510.          else
  511.             {
  512.                strcpy(cs, (TEXT *)ardnetinf->cs);
  513.                strcpy(netn, (TEXT *)ardnetinf->netn);
  514.                *cspp = cs;
  515.                *netnpp = netn;
  516.             }
  517.       }
  518. }
  519.  
  520. /* FUNCTION */
  521. EXPORT TEXT *ug_getinstrt()
  522. {
  523.    RPC_AREA_T  *rpc;
  524.    static TEXT ag_msg[INALC];
  525.    
  526.    rpc = &Data_transfer_ptr->RPC_area;
  527.    rpc->request = REQ_UG_GETINSTRT;
  528.    
  529.    send_request_with_id();
  530.    
  531.    strcpy(ag_msg, (TEXT *)rpc->all_arg_lists.argmsg.ag_msg);
  532.    
  533.    return(ag_msg);
  534. }
  535.  
  536. /* FUNCTION */
  537. EXPORT NINT ug_loadnet( NetName )
  538. TEXT *NetName;   /* root name of network to load */
  539. {
  540.    RPC_AREA_T *rpc;
  541.    
  542.    rpc = &Data_transfer_ptr->RPC_area;
  543.    rpc->request = REQ_UG_LOADNET;
  544.    strcpy(rpc->all_arg_lists.argn.ag_NetN, NetName);
  545.    
  546.    send_request_with_id();
  547.    
  548.    return((NINT)rpc->return_value.buffer_int);
  549. }
  550.  
  551. /* */
  552. /* FUNCTION */
  553. EXPORT NINT ug_learn( trials )
  554. TRIAL_NUM_T trials;
  555. {
  556.    RPC_AREA_T *rpc;
  557.    ARGLR      *arglr;
  558.    
  559.    rpc = &Data_transfer_ptr->RPC_area;
  560.    rpc->request = REQ_UG_LEARN;
  561.    arglr = &rpc->all_arg_lists.arglr;
  562.    arglr->ag_count = (BUFFER_LONG)trials;
  563.    
  564.    send_request_with_id();
  565.    
  566.    return((NINT)rpc->return_value.buffer_int);
  567. }
  568.  
  569. /* FUNCTION */
  570. EXPORT NINT ug_recall( trials )
  571. TRIAL_NUM_T trials;
  572. {
  573.    RPC_AREA_T *rpc;
  574.    ARGLR      *arglr;
  575.    
  576.    rpc = &Data_transfer_ptr->RPC_area;
  577.    rpc->request = REQ_UG_RECALL;
  578.    arglr = &rpc->all_arg_lists.arglr;
  579.    arglr->ag_count = (BUFFER_LONG)trials;
  580.    
  581.    send_request_with_id();
  582.    
  583.    return((NINT)rpc->return_value.buffer_int);
  584. }
  585.  
  586. /* FUNCTION */
  587. EXPORT NINT ug_test( trials )
  588. TRIAL_NUM_T trials;
  589. {
  590.    RPC_AREA_T *rpc;
  591.    ARGLR      *arglr;
  592.    
  593.    rpc = &Data_transfer_ptr->RPC_area;
  594.    rpc->request = REQ_UG_TEST;
  595.    arglr = &rpc->all_arg_lists.arglr;
  596.    arglr->ag_count = (BUFFER_LONG)trials;
  597.    
  598.    send_request_with_id();
  599.    
  600.    return((NINT)rpc->return_value.buffer_int);
  601. }
  602.  
  603. /* FUNCTION */
  604. EXPORT NINT ug_savebest(svb_lcnt, svb_tint, svb_nret, svb_logf, svb_fn,
  605.                         svb_prfl, svb_prmx, svb_prtol)
  606. SL        svb_lcnt;     /* learn count */
  607. SL        svb_tint;     /* test interval */
  608. SL        svb_nret;     /* number of retries before halting */
  609. NINT      svb_logf;     /* Log flag */
  610. TEXT     *svb_fn;       /* File name to save to */
  611. NINT      svb_prfl;     /* Prune flag */
  612. NINT      svb_prmx;     /* Max # units to prune */
  613. REAL      svb_prtol;    /* tolerance */
  614. {
  615.    RPC_AREA_T   *rpc;
  616.    ASAVEBEST    *asavebest;
  617.    
  618.    rpc = &Data_transfer_ptr->RPC_area;
  619.    rpc->request = REQ_UG_SAVEBEST;
  620.    asavebest = &rpc->all_arg_lists.asavebest;
  621.    
  622.    if (svb_fn != (TEXT *)0) {
  623.       strncpy(rpc->all_arg_lists.asavebest.svb_fn, svb_fn, FNLEN);
  624.       rpc->all_arg_lists.asavebest.svb_fn[FNALC-1] = '\0';
  625.    }
  626.    else
  627.       rpc->all_arg_lists.asavebest.svb_fn[0] = '\0';
  628.    
  629.    asavebest->svb_lcnt = svb_lcnt;
  630.    asavebest->svb_tint = svb_tint ;
  631.    asavebest->svb_nret = svb_nret;
  632.    asavebest->svb_logf = svb_logf;
  633.    asavebest->svb_prfl = svb_prfl;
  634.    asavebest->svb_prmx = svb_prmx;
  635.    asavebest->svb_prtol = svb_prtol;
  636.    
  637.    send_request_with_id();
  638.    
  639.    return((NINT) rpc->return_value.buffer_int);
  640. }
  641.  
  642. EXPORT NINT ug_cclrn(max_nd, n_cand, v_max, ret_f,
  643.                      stb_maxepoch, stb_patience, stb_rmsetol)
  644. NINT       max_nd;             /* Max nodes to try out */
  645. NINT       n_cand;             /* Number of candidates */
  646. NINT       v_max;              /* Maximum dimension of vector candidate */
  647. NINT       ret_f;              /* =1: Retrain tenured PEs */
  648. NINT       stb_maxepoch;       /* Stability criterion - Maximum # epochs */
  649. NINT       stb_patience;       /* Stability criterion - Patience */
  650. REAL       stb_rmsetol;        /* Stability criterion - RMS error tolerance */
  651. {
  652.    RPC_AREA_T   *rpc;
  653.    ACCLRN       *acclrn;
  654.    
  655.    rpc = &Data_transfer_ptr->RPC_area;
  656.    rpc->request = REQ_UG_CCLRN;
  657.    acclrn = &rpc->all_arg_lists.acclrn;
  658.    
  659.    acclrn->max_nd       = max_nd;
  660.    acclrn->n_cand       = n_cand;
  661.    acclrn->v_max        = v_max;
  662.    acclrn->ret_f        = ret_f;
  663.    acclrn->stb_maxepoch = stb_maxepoch;
  664.    acclrn->stb_patience = stb_patience;
  665.    acclrn->stb_rmsetol  = stb_rmsetol;
  666.    
  667.    send_request_with_id();
  668.    
  669.    return((NINT) rpc->return_value.buffer_int);
  670.  
  671. }
  672.  
  673. /* FUNCTION */
  674. EXPORT NINT ug_msgio( msg, msgl, rwf )
  675. TEXT *msg;       /* message to send / read */
  676. NINT msgl;       /* message length */
  677. NINT rwf;        /* 0=read; 1=write */
  678. {
  679.    RPC_AREA_T *rpc;
  680.    ARGMSG     *argmsg;
  681.    
  682.    rpc = &Data_transfer_ptr->RPC_area;
  683.    rpc->request = REQ_UG_MSGIO;
  684.    argmsg = &rpc->all_arg_lists.argmsg;
  685.    argmsg->ag_msgl = msgl;
  686.    argmsg->ag_msgdir = (BUFFER_UINT)rwf;
  687.    if (rwf)
  688.       strcpy(argmsg->ag_msg, msg);
  689.    
  690.    send_request_with_id();
  691.    
  692.    if (UIO_error_value == 0)
  693.       {
  694.          if (!rwf)
  695.             strcpy(msg, argmsg->ag_msg);
  696.       }
  697.    return((NINT)rpc->return_value.buffer_int);
  698. }
  699.  
  700. /* */
  701. /* FUNCTION */
  702. EXPORT VOID ug_wtstats( PStat )
  703. PRSTATS *PStat;  /* statistics */
  704. {
  705.    RPC_AREA_T  *rpc;
  706.    PRSTATS_BUF *prstats_buf;
  707.    NINT        lcv;
  708.    
  709.    rpc = &Data_transfer_ptr->RPC_area;
  710.    rpc->request = REQ_UG_WTSTATS;
  711.    
  712.    send_request_with_id();
  713.    
  714. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  715.    MOVEMEM(PStat, prstats_buf, sizeof(PRSTATS_BUF));
  716. #else
  717.    prstats_buf = &rpc->all_arg_lists.prstats_buf;
  718.    PStat->PRNwts = prstats_buf->PRNwts;
  719.    PStat->PRMin = prstats_buf->PRMin;
  720.    PStat->PRMax = prstats_buf->PRMax;
  721.    PStat->PRSum = prstats_buf->PRSum;
  722.    PStat->PRAverage = prstats_buf->PRAverage;
  723.    PStat->PRMedian = prstats_buf->PRMedian;
  724.    for (lcv=0; lcv<NPHIST; lcv++)
  725.       PStat->PRHist[lcv] = prstats_buf->PRHist[lcv];
  726.    PStat->PRMinA = prstats_buf->PRMinA;
  727.    PStat->PRMaxA = prstats_buf->PRMaxA;
  728.    PStat->PRSumA = prstats_buf->PRSumA;
  729.    PStat->PRAverageA = prstats_buf->PRAverageA;
  730.    PStat->PRMedianA = prstats_buf->PRMedianA;
  731.    for (lcv=0; lcv<NPHIST; lcv++)
  732.       PStat->PRHistA[lcv] = prstats_buf->PRHistA[lcv];
  733. #endif
  734. }
  735.  
  736. /* FUNCTION */
  737. EXPORT VOID ug_prune( mode, PrThresh, Prob, WtMax )
  738. NINT mode;     /* prune mode */
  739. REAL PrThresh; /* pruning threshold */
  740. REAL Prob;     /* stochastic probability */
  741. REAL WtMax;    /* maximum magnitude to limit wts to */
  742. {
  743.    RPC_AREA_T *rpc;
  744.    ARGPRUNE *argprune;
  745.    
  746.    rpc = &Data_transfer_ptr->RPC_area;
  747.    rpc->request = REQ_UG_PRUNE;
  748.    argprune = &rpc->all_arg_lists.argprune;
  749.    argprune->pr_mode = (BUFFER_UINT)mode;
  750.    argprune->pr_thresh = (BUFFER_REAL)PrThresh;
  751.    argprune->pr_prob = (BUFFER_REAL)Prob;
  752.    argprune->pr_wtmax = (BUFFER_REAL)WtMax;
  753.    
  754.    send_request_with_id();
  755. }
  756.  
  757. /* */
  758. /* FUNCTION */
  759. EXPORT VOID ug_blit(key, mode, x0, y0, x_exp, y_exp, x_size, y_size, data)
  760. NINT key;           /* window number for a handle (1..8) */
  761. NINT mode;          /* 0=set, 1=xor */
  762. NINT x0, y0;        /* window relative coordinates for lower left corner */
  763. NINT x_exp, y_exp;  /* How many pixels to expand each bit in the x and */
  764. /*   y direction                                   */
  765. NINT x_size,y_size; /* the size of the mask in the x and y direction   */
  766. TEXT *data;         /* the data to be blitted. one byte per char and   */
  767. /* the value of that byte determines the color put */
  768. /* on the screen. The bytes start at bottom right  */
  769. /* and then fill the first row, then next row up   */
  770. /* to top.                                         */
  771. {
  772.    RPC_AREA_T *rpc;
  773.    ARGBLIT    *argblit;
  774.    
  775.    rpc = &Data_transfer_ptr->RPC_area;
  776.    rpc->request = REQ_UG_BLIT;
  777.    argblit = &rpc->all_arg_lists.argblit;
  778.    argblit->ag_winn = (BUFFER_UINT)key;
  779.    argblit->ag_mode = (BUFFER_UINT)mode;
  780.    argblit->ag_x0 = (BUFFER_UINT)x0;
  781.    argblit->ag_y0 = (BUFFER_UINT)y0;
  782.    argblit->ag_x_exp = (BUFFER_UINT)x_exp;
  783.    argblit->ag_y_exp = (BUFFER_UINT)y_exp;
  784.    argblit->ag_x_size = (BUFFER_UINT)x_size;
  785.    argblit->ag_y_size = (BUFFER_UINT)y_size;
  786.    MOVEMEM(argblit->ag_blit_bytes, data, x_size*y_size);
  787.    
  788.    send_request_with_id();
  789. }
  790.  
  791. /* FUNCTION */
  792. EXPORT VOID ug_pblit( key, color, mode, x0, y0, wid, ht, rot, ptr )
  793. NINT key;        /* window handle */
  794. NINT color;      /* color of pattern */
  795. NINT mode;       /* 0=set, 1=xor */
  796. NINT x0, y0;     /* window relative coordinates for lower left corner */
  797. NINT wid, ht;    /* width & height of blit area in pixels */
  798. NINT rot;        /* rotation angle */
  799. TEXT *ptr;       /* pointer to the blit data */
  800. {
  801.    RPC_AREA_T *rpc;
  802.    ARGPBLIT   *argpblit;
  803.    
  804.    rpc = &Data_transfer_ptr->RPC_area;
  805.    rpc->request = REQ_UG_PBLIT;
  806.    argpblit = &rpc->all_arg_lists.argpblit;
  807.    argpblit->ag_winn = (BUFFER_UINT)key;
  808.    argpblit->ag_color = (BUFFER_UINT)color;
  809.    argpblit->ag_mode = (BUFFER_UINT)mode;
  810.    argpblit->ag_x0 = (BUFFER_UINT)x0;
  811.    argpblit->ag_y0 = (BUFFER_UINT)y0;
  812.    argpblit->ag_x_size = (BUFFER_UINT)wid;
  813.    argpblit->ag_y_size = (BUFFER_UINT)ht;
  814.    argpblit->ag_rot = rot;
  815.    MOVEMEM(argpblit->ag_blit_bytes, ptr, wid*ht);
  816.    
  817.    send_request_with_id();
  818. }
  819.  
  820. /* */
  821. /* FUNCTION */
  822. EXPORT NINT ug_peio( apep, rwf, LayN, PEN )
  823. APE  *apep;      /* poiner to PE data */
  824. NINT rwf;        /* 0=read; 1=write */
  825. NINT LayN;       /* layer number 0=input,... */
  826. NINT PEN;        /* PE within layer 0=first, ... */
  827. {
  828.    RPC_AREA_T *rpc;
  829.    ARGPSCIO   *argpscio;
  830.    
  831.    rpc = &Data_transfer_ptr->RPC_area;
  832.    rpc->request = REQ_UG_PEIO;
  833.    argpscio = &rpc->all_arg_lists.argpscio;
  834.    argpscio->ag_rwf = (BUFFER_UINT)rwf;
  835.    argpscio->ag_layern = LayN;
  836.    argpscio->ag_pen = PEN;
  837.    if (rwf)
  838.       {
  839. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  840.          MOVEMEM(&argpscio->ag_rdata.ag_pe, apep, sizeof(APE));
  841. #else
  842.          argpscio->ag_rdata.ag_pe.ape_I = apep->ape_I;
  843.          argpscio->ag_rdata.ag_pe.ape_Tran = apep->ape_Tran;
  844.          argpscio->ag_rdata.ag_pe.ape_Output = apep->ape_Output;
  845.          argpscio->ag_rdata.ag_pe.ape_Err = apep->ape_Err;
  846.          argpscio->ag_rdata.ag_pe.ape_CumErr = apep->ape_CumErr;
  847.          argpscio->ag_rdata.ag_pe.ape_Flags = apep->ape_Flags;
  848. #endif
  849.       }
  850.    
  851.    send_request_with_id();
  852.    
  853.    if (!rwf)
  854.       {
  855. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  856.          MOVEMEM(apep, &argpscio->ag_rdata.ag_pe, sizeof(APE));
  857. #else
  858.          apep->ape_I = argpscio->ag_rdata.ag_pe.ape_I;
  859.          apep->ape_Tran = argpscio->ag_rdata.ag_pe.ape_Tran;
  860.          apep->ape_Output = argpscio->ag_rdata.ag_pe.ape_Output;
  861.          apep->ape_Err = argpscio->ag_rdata.ag_pe.ape_Err;
  862.          apep->ape_CumErr = argpscio->ag_rdata.ag_pe.ape_CumErr;
  863.          apep->ape_Flags = argpscio->ag_rdata.ag_pe.ape_Flags;
  864. #endif
  865.       }
  866.    
  867.    return((NINT)rpc->return_value.buffer_int);
  868. }
  869.  
  870. /* */
  871. /* FUNCTION */
  872. EXPORT NINT ug_schdio( schp, rwf, LayN )
  873. ASCHED *schp;    /* pointer to schedule date */
  874. NINT   rwf;      /* 0=read; 1=write */
  875. NINT   LayN;     /* layer number 0=input, ... */
  876. {
  877.    RPC_AREA_T *rpc;
  878.    ARGPSCIO   *argpscio;
  879.    
  880.    rpc = &Data_transfer_ptr->RPC_area;
  881.    rpc->request = REQ_UG_SCHDIO;
  882.    argpscio = &rpc->all_arg_lists.argpscio;
  883.    argpscio->ag_rwf = (BUFFER_UINT)rwf;
  884.    argpscio->ag_layern = LayN;
  885.    if (rwf)
  886.       {
  887. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  888.          MOVEMEM(&argpscio->ag_rdata.ag_sched, schp, sizeof(ASCHED));
  889. #else
  890.          int lcv1, lcv2;
  891.          
  892.          strcpy(argpscio->ag_rdata.ag_sched.asc_nam, schp->asc_nam);
  893.          for (lcv1=0; lcv1<5; lcv1++) {
  894.             argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_recall =
  895.                schp->asc_col[lcv1].asc_recall;
  896.             for (lcv2=0; lcv2<10; lcv2++) {
  897.                argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_rcl[lcv2] =
  898.                   schp->asc_col[lcv1].asc_rcl[lcv2];
  899.             }
  900.             argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_learn =
  901.                schp->asc_col[lcv1].asc_learn;
  902.             for (lcv2=0; lcv2<10; lcv2++) {
  903.                argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_lrn[lcv2] =
  904.                   schp->asc_col[lcv1].asc_lrn[lcv2];
  905.             }
  906.          }
  907. #endif
  908.       }
  909.    
  910.    send_request_with_id();
  911.    
  912.    /* */
  913.    if (UIO_error_value == 0)
  914.       {
  915.          if (!rwf) {
  916. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  917.             MOVEMEM(schp, &argpscio->ag_rdata.ag_sched, sizeof(ASCHED));
  918. #else
  919.             int lcv1, lcv2;
  920.             
  921.             strcpy(schp->asc_nam, argpscio->ag_rdata.ag_sched.asc_nam);
  922.             for (lcv1=0; lcv1<5; lcv1++) {
  923.                schp->asc_col[lcv1].asc_recall =
  924.                   argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_recall;
  925.                for (lcv2=0; lcv2<10; lcv2++) {
  926.                   schp->asc_col[lcv1].asc_rcl[lcv2] =
  927.                      argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_rcl[lcv2];
  928.                }
  929.                schp->asc_col[lcv1].asc_learn =
  930.                   argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_learn;
  931.                for (lcv2=0; lcv2<10; lcv2++) {
  932.                   schp->asc_col[lcv1].asc_lrn[lcv2] =
  933.                      argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_lrn[lcv2];
  934.                }
  935.             }
  936. #endif
  937.          }
  938.       }
  939.    
  940.    return((NINT)rpc->return_value.buffer_int);
  941. }
  942.  
  943. /* */
  944. /* FUNCTION */
  945. EXPORT NINT ug_ctrio( ctrp, rwf)
  946. CTRIO_T *ctrp;        /* pointer to array of 8-LONGs */
  947. NINT    rwf;          /* 0=read; 1=write */
  948. {
  949.    RPC_AREA_T *rpc;
  950.    ARGPSCIO   *argpscio;
  951.    NINT       lcv;
  952.    
  953.    rpc = &Data_transfer_ptr->RPC_area;
  954.    rpc->request = REQ_UG_CTRIO;
  955.    argpscio = &rpc->all_arg_lists.argpscio;
  956.    argpscio->ag_rwf = (BUFFER_UINT)rwf;
  957.    if (rwf)
  958. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  959.       MOVEMEM(argpscio->ag_rdata.ag_ctr, ctrp, sizeof(CTRIO_T) * 8);
  960. #else
  961.    for (lcv=0; lcv<8; lcv++)
  962.       argpscio->ag_rdata.ag_ctr[lcv] = (BUFFER_LONG)ctrp[lcv];
  963. #endif
  964.    
  965.    send_request_with_id();
  966.    
  967.    if (UIO_error_value == 0)
  968.       {
  969.          if (!rwf)
  970. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  971.             MOVEMEM(ctrp, argpscio->ag_rdata.ag_ctr, sizeof(CTRIO_T) * 8);
  972. #else
  973.          for (lcv=0; lcv<8; lcv++)
  974.             ctrp[lcv] = (SL)argpscio->ag_rdata.ag_ctr[lcv];
  975. #endif
  976.       }
  977.    return((NINT)rpc->return_value.buffer_int);
  978. }
  979.  
  980. /* */
  981. /* FUNCTION */
  982. EXPORT NINT ug_lyrio( lyrp, rwf, LayN )
  983. ALYR   *lyrp;     /* pointer to layer info structure */
  984. NINT    rwf;      /* 0=read; 1=write */
  985. NINT    LayN;     /* layer number 0=input, ... */
  986. {
  987.    RPC_AREA_T *rpc;
  988.    ARGPSCIO   *argpscio;
  989.    
  990.    rpc = &Data_transfer_ptr->RPC_area;
  991.    rpc->request = REQ_UG_LYRIO;
  992.    argpscio = &rpc->all_arg_lists.argpscio;
  993.    argpscio->ag_rwf = (BUFFER_UINT)rwf;
  994.    argpscio->ag_layern = LayN;
  995.  
  996.    if (rwf) {
  997.       argpscio->ag_rdata.ag_lyr.scale      = lyrp->scale;
  998.       argpscio->ag_rdata.ag_lyr.offst      = lyrp->offst;
  999.       argpscio->ag_rdata.ag_lyr.fprm_offst = lyrp->fprm_offst;
  1000.       argpscio->ag_rdata.ag_lyr.low_init   = lyrp->low_init;
  1001.       argpscio->ag_rdata.ag_lyr.high_init  = lyrp->high_init;
  1002.    }
  1003.  
  1004.    send_request_with_id();
  1005.    
  1006.    if (!rwf)  {
  1007.       lyrp->num_pes     = argpscio->ag_rdata.ag_lyr.num_pes;
  1008.       lyrp->n_wt_flds   = argpscio->ag_rdata.ag_lyr.n_wt_flds;
  1009.       lyrp->sum_f       = argpscio->ag_rdata.ag_lyr.sum_f;
  1010.       lyrp->tran_f      = argpscio->ag_rdata.ag_lyr.tran_f;
  1011.       lyrp->output_f    = argpscio->ag_rdata.ag_lyr.output_f;
  1012.       lyrp->learn_f     = argpscio->ag_rdata.ag_lyr.learn_f;
  1013.       lyrp->error_f     = argpscio->ag_rdata.ag_lyr.error_f;
  1014.       lyrp->noise_f     = argpscio->ag_rdata.ag_lyr.noise_f;
  1015.       lyrp->scale       = argpscio->ag_rdata.ag_lyr.scale;
  1016.       lyrp->offst       = argpscio->ag_rdata.ag_lyr.offst;
  1017.       lyrp->fprm_offst  = argpscio->ag_rdata.ag_lyr.fprm_offst;
  1018.       lyrp->low_init    = argpscio->ag_rdata.ag_lyr.low_init;
  1019.       lyrp->high_init   = argpscio->ag_rdata.ag_lyr.high_init;
  1020.    }
  1021.    
  1022.    return((NINT)rpc->return_value.buffer_int);
  1023. }
  1024.  
  1025. /* */
  1026. /* FUNCTION */
  1027. EXPORT NINT ug_ioparms(ioparms, rwf)
  1028. IOPARMS *ioparms;
  1029. NINT       rwf;  /* 0=read; 1=write */
  1030. {
  1031.    RPC_AREA_T  *rpc;
  1032.    IOPARMS_BUF *ioparms_buf;
  1033.    
  1034.    rpc = &Data_transfer_ptr->RPC_area;
  1035.    rpc->request = REQ_UG_IOPARMS;
  1036.    rpc->all_arg_lists.argpscio.ag_rwf = (BUFFER_UINT)rwf;
  1037.    ioparms_buf = &rpc->all_arg_lists.argpscio.ag_rdata.ioparms_buf;
  1038.    if (rwf)
  1039.       {
  1040. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  1041.          MOVEMEM(ioparms_buf, ioparms, sizeof(IOPARMS));
  1042. #else
  1043.          ioparms_buf->start_in = ioparms->start_in;
  1044.          ioparms_buf->min_in = ioparms->min_in;
  1045.          ioparms_buf->max_in = ioparms->max_in;
  1046.          ioparms_buf->start_out = ioparms->start_out;
  1047.          ioparms_buf->min_out = ioparms->min_out;
  1048.          ioparms_buf->max_out = ioparms->max_out;
  1049. #endif
  1050.       }
  1051.    
  1052.    send_request_with_id();
  1053.    
  1054.    if (UIO_error_value == 0)
  1055.       {
  1056.          if (!rwf)
  1057.             {
  1058. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  1059.                MOVEMEM(ioparms, ioparms_buf, sizeof(IOPARMS));
  1060. #else
  1061.                ioparms->start_in = ioparms_buf->start_in;
  1062.                ioparms->min_in = ioparms_buf->min_in;
  1063.                ioparms->max_in = ioparms_buf->max_in;
  1064.                ioparms->start_out = ioparms_buf->start_out;
  1065.                ioparms->min_out = ioparms_buf->min_out;
  1066.                ioparms->max_out = ioparms_buf->max_out;
  1067. #endif
  1068.             }
  1069.       }
  1070. }
  1071.  
  1072. /* */
  1073. /* FUNCTION */
  1074. EXPORT NINT ug_cnio(LayN, PEN, SLayN, SPEN, n_cn_vals,var_idx, rwf, cn_vals)
  1075. NINT   LayN;     /* layer number 0=input,... */
  1076. NINT   PEN;      /* PE within layer 0=first, ... */
  1077. NINT   SLayN;    /* source layer number 0=input,... */
  1078. NINT   SPEN;     /* start PE within source layer 0=first, ... */
  1079. NINT  *n_cn_vals; /* Number of values to write/get. 0 = all */
  1080. NINT   var_idx;  /* Identifier of variable within connection */
  1081. NINT   rwf;      /* 0=read; 1=write */
  1082. SREAL *cn_vals;  /* values */
  1083. {
  1084.    RPC_AREA_T *rpc;
  1085.    ARGCNIO    *argcnio;
  1086.    
  1087.    rpc = &Data_transfer_ptr->RPC_area;
  1088.    rpc->request = REQ_UG_CNIO;
  1089.    argcnio = &rpc->all_arg_lists.argcnio;
  1090.    argcnio->layern = LayN;
  1091.    argcnio->pen    = PEN;
  1092.    argcnio->slayern = SLayN;
  1093.    argcnio->spen    = SPEN;
  1094.    argcnio->var_idx = var_idx;
  1095.    argcnio->rwf     = (BUFFER_UINT)rwf;
  1096.    
  1097.    if (rwf)  {
  1098.       if (*n_cn_vals > MAX_CN_VALS)
  1099.          *n_cn_vals = MAX_CN_VALS;
  1100.       else if (*n_cn_vals <=0)
  1101.          *n_cn_vals = 1;
  1102.       
  1103.       argcnio->n_cn_vals = *n_cn_vals;
  1104.       
  1105.       MOVEMEM(argcnio->cn_vals, cn_vals,
  1106.               argcnio->n_cn_vals*sizeof(BUFFER_REAL));
  1107.    } else
  1108.       argcnio->n_cn_vals = *n_cn_vals;
  1109.    
  1110.    send_request_with_id();
  1111.    
  1112.    *n_cn_vals = argcnio->n_cn_vals;
  1113.    
  1114.    if (!rwf) {
  1115.       /* Note: (!rwf && *n_cn_vals==0) => give me as many
  1116.          vals as possible */
  1117.       MOVEMEM(cn_vals, argcnio->cn_vals,
  1118.               argcnio->n_cn_vals*sizeof(BUFFER_REAL));
  1119.    }
  1120.    
  1121.    return((NINT) rpc->return_value.buffer_int);
  1122. }
  1123.  
  1124. /* FUNCTION */
  1125. EXPORT NINT ug_fileio(fn, lrf, binf, rndf, ldf)
  1126. TEXT *fn;           /* File name (root only) */
  1127. NINT  lrf;          /* Learn = 0, Recall/Test = 1 */
  1128. NINT  binf;         /* Binary flag */
  1129. NINT  rndf;         /* Randomization flag */
  1130. NINT  ldf;          /* Load flag */
  1131. {
  1132.    RPC_AREA_T   *rpc;
  1133.    ARGFILEIO    *argfileio;
  1134.    
  1135.    rpc = &Data_transfer_ptr->RPC_area;
  1136.    rpc->request = REQ_UG_FILEIO;
  1137.    argfileio = &rpc->all_arg_lists.argfileio;
  1138.    
  1139.    if (fn != (TEXT *)0) {
  1140.       strncpy(rpc->all_arg_lists.argfileio.fname, fn, FNLEN);
  1141.       rpc->all_arg_lists.argfileio.fname[FNALC-1] = '\0';
  1142.    }
  1143.    else
  1144.       rpc->all_arg_lists.argfileio.fname[0] = '\0';
  1145.    
  1146.    argfileio->lrf  = lrf;
  1147.    argfileio->binf = binf;
  1148.    argfileio->rndf = rndf;
  1149.    argfileio->ldf  = ldf;
  1150.    
  1151.    send_request_with_id();
  1152.    
  1153.    return((NINT) rpc->return_value.buffer_int);
  1154. }
  1155.  
  1156. /* FUNCTION */
  1157. EXPORT NINT ug_rdfileinf(iofilen, lrf, n_recs)
  1158. TEXT **iofilen;   /* return pointer to I/O file name */
  1159. NINT   lrf;       /* Learn recall flag */
  1160. SL    *n_recs;    /* return pointer to number of records */
  1161. {
  1162.    RPC_AREA_T    *rpc;
  1163.    ARDFILEINF    *ardfileinf;
  1164.    static TEXT    filen[FNALC]  = {0};
  1165.    
  1166.    rpc = &Data_transfer_ptr->RPC_area;
  1167.    rpc->request = REQ_UG_RDFILEINF;
  1168.    ardfileinf = &rpc->all_arg_lists.ardfileinf;
  1169.    
  1170.    if (n_recs == (SL *)0)
  1171.       ardfileinf->n_recs = -1l;
  1172.    else
  1173.       ardfileinf->n_recs = 0l;
  1174.  
  1175.    ardfileinf->lrf = lrf;
  1176. #ifdef _MSC_VER
  1177.    /*
  1178.    {
  1179.    FILE *F;
  1180.    F = fopen("dump.out","w");
  1181.    fprintf(F,"lrf                = %d\n",lrf);
  1182.    fprintf(F,"ardfileinf->lrf    = %ld\n",ardfileinf->lrf);
  1183.    fprintf(F,"&(ardfileinf->iofilen) = %x\n",ardfileinf->iofilen);
  1184.    fprintf(F,"&(ardfileinf->lrf)     = %x\n",&(ardfileinf->lrf));
  1185.    fprintf(F,"&(ardfileinf->n_recs)  = %x\n",&(ardfileinf->n_recs));
  1186.    fclose(F);
  1187.    }
  1188.    */
  1189. #endif
  1190.  
  1191.    send_request_with_id();
  1192.    
  1193.    if (UIO_error_value == 0) {
  1194.       if (n_recs != (SL *)0)
  1195.          *n_recs = (SL)ardfileinf->n_recs;
  1196.       if (ardfileinf->iofilen[0] == '\0')
  1197.          *iofilen = NULL;
  1198.       else {
  1199.          strcpy(filen, (TEXT *)ardfileinf->iofilen);
  1200.          *iofilen = filen;
  1201.       }
  1202.    }
  1203. }
  1204. /* */
  1205.  
  1206. /* FUNCTION */
  1207. EXPORT NINT ug_netinit()
  1208. {
  1209.    RPC_AREA_T *rpc;
  1210.    
  1211.    rpc = &Data_transfer_ptr->RPC_area;
  1212.    rpc->request = REQ_UG_NETINIT;
  1213.    
  1214.    send_request_with_id();
  1215.    
  1216.    return((NINT)rpc->return_value.buffer_int);
  1217. }
  1218.  
  1219.  
  1220. /* FUNCTION */
  1221. EXPORT NINT ug_randseed(seed)
  1222. SL  seed;
  1223. {
  1224.    RPC_AREA_T *rpc;
  1225.    
  1226.    rpc = &Data_transfer_ptr->RPC_area;
  1227.    rpc->request = REQ_UG_RANDSEED;
  1228.    
  1229.    rpc->all_arg_lists.arandseed.seed = seed;
  1230.  
  1231.    send_request_with_id();
  1232.    
  1233.    return((NINT)rpc->return_value.buffer_int);
  1234. }
  1235.  
  1236.  
  1237. VOID InitGMenu( gmp, chrx, chry ) /* Initialize most menu params */
  1238. GMENU *gmp;   /* Graphics menu pointer */
  1239. int  chrx, chry;  /* character dimensions */
  1240. {
  1241.    GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  1242.    int   wx; /* work index */
  1243.    int   nmi;  /* number of menu items */
  1244.    int   tsl;  /* total string length */
  1245.    /* int   tpl; */ /* total pixel length */
  1246.    int   x0, y0, x1, y1, ytxt;
  1247.    int   chrxover2; /* x margin */
  1248.    
  1249.    tsl = 0;
  1250.    nmi = gmp->num_items;
  1251.    /* Count total number of characters */
  1252.    for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  1253.       tsl += strlen( gmip->text );
  1254.    
  1255.    /* tpl = (nmi + tsl) * chrx + 1; */
  1256.    
  1257.    /* Fill in item structures */
  1258.    y0 = 1;
  1259.    y1 = y0 + 2 * GM_MARGIN + chry - 1;
  1260.    if ( (gmp->flag & GM_AUX) != 0 ) y1 += GM_MARGIN + chry;
  1261.    ytxt = y1 - GM_MARGIN - chry;
  1262.    chrxover2 = chrx / 2;
  1263.    x0 = 1;
  1264.    for (gmip = gmp->item, wx = 0; wx < nmi ; gmip++ , wx++) {
  1265.       x1 = x0 + (1+strlen( gmip->text )) * chrx - 1;
  1266.       gmip->x0 = x0;
  1267.       gmip->x1 = x1;
  1268.       gmip->y0 = y0;
  1269.       gmip->y1 = y1;
  1270.       /* text always aligned on character size boundary rel to start of menu */
  1271.       gmip->xt = x0 + chrxover2;
  1272.       gmip->yt = ytxt;
  1273.       x0 = x1 + 2;
  1274.       gmip->flag = 0x0000;
  1275.    }
  1276.    
  1277.    gmp->x1 = x1 + 1;
  1278.    gmp->y1 = y1 + 1;
  1279. }
  1280.  
  1281.  
  1282. VOID DispGMenu( gmp )
  1283. GMENU *gmp;   /* Graphics menu pointer */
  1284. {
  1285.    GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  1286.    int   nmi;  /* number of menu items */
  1287.    int   wx; /* work nint */
  1288.    
  1289.    /* Display outline */
  1290.    nmi = gmp->num_items;
  1291.    
  1292.    for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  1293.       ug_line( gmp->key, gm_outcolor, 0,
  1294.               gmp->x0 + gmip->x0 - 1, gmp->y0,
  1295.               gmp->x0 + gmip->x0 - 1, gmp->y0 + gmp->y1, 0 );
  1296.    
  1297.    ug_line( gmp->key, gm_outcolor, 0,
  1298.            gmp->x0 + gmp->x1, gmp->y0,
  1299.            gmp->x0 + gmp->x1, gmp->y0 + gmp->y1, 0 );
  1300.    
  1301.    /* Draw horizontal lines */
  1302.    ug_line( gmp->key, gm_outcolor, 0,
  1303.            gmp->x0, gmp->y0,
  1304.            gmp->x0 + gmp->x1, gmp->y0, 0 );
  1305.    ug_line( gmp->key, gm_outcolor, 0,
  1306.            gmp->x0, gmp->y0 + gmp->y1,
  1307.            gmp->x0 + gmp->x1, gmp->y0 + gmp->y1, 0 );
  1308.    
  1309.    for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ ) {
  1310.       gmip->flag &= ~GM_HILITE; /* Unhighlight */
  1311.       DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor );
  1312.    }
  1313. }
  1314.  
  1315.  
  1316. VOID DispGItem( gmp, gmip, text_color, back_color )
  1317. GMENU   *gmp;   /* Graphics menu pointer */
  1318. GMENU_ITEM  *gmip;    /* Graphics menu item pointer */
  1319. int   text_color;
  1320. int   back_color;
  1321. {
  1322.    ug_boxf( gmp->key, back_color, 0,
  1323.            gmp->x0 + gmip->x0, gmp->y0 + gmip->y0,
  1324.            gmp->x0 + gmip->x1, gmp->y0 + gmip->y1 );
  1325.    ug_puts( gmp->key, text_color, 0,
  1326.            gmp->x0 + gmip->xt, gmp->y0 + gmip->yt, gmip->text, 0 );
  1327.    if ( (gmp->flag & GM_AUX) != 0 )
  1328.       ug_puts( gmp->key, text_color, 0,
  1329.               gmp->x0 + gmip->xt, gmp->y0 + gmip->y0 + GM_MARGIN - 1,
  1330.               gmip->text2, 0 );
  1331. }
  1332.  
  1333.  
  1334. GMENU_ITEM *LookGMenu( gmp , button ) /* returns item and button code */
  1335. GMENU *gmp;   /* Graphics menu pointer */
  1336. int *button;  /* returned button code */
  1337. {
  1338.    GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  1339.    GMENU_ITEM  *rgmip; /* Returned graphics menu item pointer */
  1340.    int   nmi;  /* Number of menu items */
  1341.    int   key, xp, yp;  /* for mouse call */
  1342.    int   wx; /* work nint */
  1343.    
  1344.    rgmip = (GMENU_ITEM *) 0;
  1345.    nmi = gmp->num_items;
  1346.    
  1347.    ug_mouse( &key, &xp, &yp, button );
  1348.    xp = xp - gmp->x0;
  1349.    yp = yp - gmp->y0;
  1350.    if ( key == gmp->key ) { /* Find item pointed to and highlight */
  1351.       for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ ) {
  1352.          if ( xp >= gmip->x0 && xp <= gmip->x1 &&
  1353.              yp >= gmip->y0 && yp <= gmip->y1 &&
  1354.              rgmip == (GMENU_ITEM *)0 &&
  1355.              (gmip->flag & GM_LOCKED) == 0 )
  1356.             {
  1357.                if ( (gmip->flag & GM_HILITE) == 0) {
  1358.                   gmip->flag |= GM_HILITE;
  1359.                   DispGItem( gmp, gmip, gm_intcolor, gm_txtcolor ); /* highlight */
  1360.                }
  1361.                rgmip = gmip;
  1362.             } else if ( (gmip->flag & GM_HILITE) != 0) {
  1363.                gmip->flag &= ~GM_HILITE;
  1364.                DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor ); /* Unhighlight */
  1365.             }
  1366.       }
  1367.    } else {  /* Unhilight any highlighted items */
  1368.       for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  1369.          if ( (gmip->flag & GM_HILITE) != 0) {
  1370.             gmip->flag &= ~GM_HILITE;
  1371.             DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor ); /* Unhighlight */
  1372.          }
  1373.    }
  1374.    
  1375.    return( rgmip );
  1376. }
  1377.